import request from '@/utils/request'

// 查询接口列表
export function listInterface(query) {
  return request({
    url: '/business/interface/list',
    method: 'get',
    params: query
  })
}

// 查询接口详细
export function getInterface(id) {
  return request({
    url: '/business/interface/' + id,
    method: 'get'
  })
}

// 新增接口
export function addInterface(data) {
  return request({
    url: '/business/interface',
    method: 'post',
    data: data
  })
}

// 修改接口
export function updateInterface(data) {
  return request({
    url: '/business/interface',
    method: 'put',
    data: data
  })
}

// 删除接口
export function delInterface(id) {
  return request({
    url: '/business/interface/' + id,
    method: 'delete'
  })
}
// 非查询接口列表
export function listInterfaceAll(query) {
  return request({
    url: '/business/interface/listAll',
    method: 'get',
    params: query
  })
}
// 查询所有接口树列表
export function tree(query) {
  return request({
    url: '/business/interface/tree',
    method: 'get',
    params: query
  })
}
// 产生sql
export function generatesql(data) {
  return request({
    url: '/business/interface/generatesql',
    method: 'post',
    data: data
  })
}
/**
 * 将后台传过来的参数转换为API需要的参数
 * @param jsonParameters
 * @param parentName 父级名称
 */
export function convert2ApiJson(jsonParameters) {
  let apiJsonObj ={};
  console.log('convert2ApiJson jsonParameters:'+JSON.stringify(jsonParameters));
  for(let i=0;i<jsonParameters.length;i++){
    if(!hasSubLevels(jsonParameters[i].children)) {
      apiJsonObj[jsonParameters[i].parameterName] = jsonParameters[i].parameterValue ||jsonParameters[i].defaultValue|| '';
    }else{
      apiJsonObj[jsonParameters[i].parameterName] = convert2ApiJson(jsonParameters[i].children)
    }
  }
  return apiJsonObj;
}

/**
 * 判断json是否还有下级
 * @param node
 */
export function hasSubLevels(node) {
  return typeof node === 'object' && node !== null && Object.keys(node).length > 0;
}

/**
 * 执行请求
 * @param interfaceInfo
 * @param parameters
 * @returns {*}
 */
export function doRequest(interfaceInfo,parameters) {
  if(interfaceInfo.interfaceMethod.toLowerCase() === 'get') {
    let fullUrl = interfaceInfo.interfaceUrl;
    if(Object.keys(parameters).length>0) {
      if (!fullUrl.endsWith("?")) {
        fullUrl = fullUrl + "?"
      }
      //循环拼接parameters到fullUrl后面
      for (let key in parameters) {
        if (parameters.hasOwnProperty(key)) {
          if (fullUrl.endsWith("&")||fullUrl.endsWith("?")) {
            fullUrl = fullUrl + key + "=" + parameters[key]
          } else {
            fullUrl = fullUrl + "&" + key + "=" + parameters[key]
          }
        }
      }
    }
    console.log('fullUrl:'+fullUrl)
    return request({
      url: fullUrl,
      method: 'get'
    })
  }else{
    return request({
      url: interfaceInfo.interfaceUrl,
      method: interfaceInfo.interfaceMethod,
      data: parameters
    })
  }
}

/**
 * 将多层的json对象转换为扁平的json对象，上下级关系转换为点连接
 * @param obj
 * @param prefix
 * @param flatObj
 * @returns {{}}
 */
export function flatten(obj, prefix = '', flatObj = {}) {
  for (let key in obj) {
    if (obj.hasOwnProperty(key)) {
      if (typeof obj[key] === 'object' && obj[key] !== null && !Array.isArray(obj[key])) {
        // 如果值是对象，则递归调用 flatten 函数
        flatten(obj[key], prefix + key + '.', flatObj);
      } else {
        // 如果值不是对象，则直接添加到结果对象中
        flatObj[prefix + key] = obj[key];
      }
    }
  }
  return flatObj;
}

/**
 * 递归查找满足条件的json路径数组
 */
export function findPathsByCondition(obj, condition, currentPath = '') {
  let paths = [];

  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      const newPath = currentPath ? `${currentPath}.${key}` : key;

      if (typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
        // 如果是对象，则递归调用
        paths = paths.concat(findPathsByCondition(obj[key], condition, newPath.toString()));
      } else if (Array.isArray(obj[key])) {
        // 如果是数组，则遍历数组元素
        obj[key].forEach((item, index) => {
          const itemPath = `${newPath}[${index}]`;
          if (typeof item === 'object') {
            // 如果数组元素是对象，则递归调用
            paths = paths.concat(findPathsByCondition(item, condition, itemPath.toString()));
          } else {
            // 如果数组元素不是对象，则检查是否满足条件
            if (condition(item)) {
              paths.push(itemPath);
            }
          }
        });
      } else {
        // 检查非对象属性是否满足条件
        if (condition(obj[key])) {
          paths.push(newPath);
        }
      }
    }
  }

  return paths;
}

/**
 * 根据json路径获取值
 */
export function getValueByPath(obj, path) {
  // 分割路径字符串
   const keys = path.split('.'); // 使用正则表达式来分割路径

  // 递归访问对象属性
  return keys.reduce((prev, curr) => {
    if (prev && typeof prev === 'object') {
      if (!Array.isArray(prev)) {
        //判断字符串是否带[]
        if(curr.includes('[') && curr.includes(']')) {
          //提取【】之前的属性
          let spos = curr.indexOf('[');
          let propsName = curr.substring(0,spos);
          let end = curr.indexOf(']');
          const index = curr.substring(spos+1,end)
          return prev[propsName][Number(index)];
        }else {
          return prev[curr];
        }
      } else if(isNumeric(curr))    {
        const index = parseInt(curr, 10);
        return prev[index];
      } else {
        //判断字符串是否带[]
        if(curr.includes('[') && curr.includes(']')) {
          //提取【】之前的属性
          let spos = curr.indexOf('[');
          let propsName = curr.substring(0,spos);
          let end = curr.indexOf(']');
          const index = curr.substring(spos+1,end)
          return prev[propsName][Number(index)];
        }else{
          return prev[curr];
        }
      }
    }
    return undefined;
  }, obj);
}
function isNumeric(str) {
  return !isNaN(Number(str));
}

/**
 * 转换返回值定义模板为扁平json，只保留有绑定组件
 * @param data
 * @returns {{}}
 */
export function convertReturnValueToFlatten(data) {
  // 新的对象或数组用于存储处理后的数据
  let newData={};

  // 判断当前数据是数组还是对象
  if (Array.isArray(data)) {
    // 如果是数组，则处理数组中的每个元素
    for(let i = 0; i < data.length; i++) {
      // newData = data.map(item => convertReturnValueToFlatten(item));

      let tempJson = convertReturnValueToFlatten(data[i]);
      if(JSON.stringify(tempJson)!="{}"){
        // newData = [];
        // newData.push(tempJson);
        newData = deepMerge(newData,tempJson)
      }
    }
    console.log(newData)
    return newData;
  } else {
    // 如果是对象，则处理对象中的每个子项
    newData = {};
    if (data.returnName && data.componentId) {
      newData[data.returnName] = data.componentId;
    }
    Object.entries(data).forEach(([key, value]) => {
      if (Array.isArray(value) && value.length > 0) {
        let newValue = {};
        for(let i = 0; i < value.length; i++){
          let tempJson = convertReturnValueToFlatten(value[i]);
          if(JSON.stringify(tempJson)!="{}") {
            // newValue.push(tempJson);
            newValue = deepMerge(newValue,tempJson)
          }
        }

        //排除空的节点
        if(JSON.stringify(newValue)!='{}') {
          newData[data.returnName] = newValue;
        }
      }
    });
    console.log(newData)
    return newData;
  }

  return newData;
}
//查询json对象当前层属性个数
function getCurrentLayerPropertyCount(obj) {
  // 使用 Object.keys() 获取对象的所有可枚举属性名
  const keys = Object.keys(obj);
  // 返回属性名数组的长度
  return keys.length;
}

/**
 * 深度合并两个对象
 * @param target
 * @param source
 * @returns {*}
 */
function deepMerge(target, source) {
  let output = Object.assign({}, target);
  if (typeof source !== 'object' || source === null) return source;
  Object.keys(source).forEach(key => {
    if (typeof source[key] === 'object' && source[key] !== null) {
      if (!(key in output)) Object.assign(output, { [key]: {} });
      output[key] = deepMerge(output[key], source[key]);
    } else {
      Object.assign(output, { [key]: source[key] });
    }
  });
  return output;
}


